const { users, User } = require('../models/User');
const { generateId } = require('../utils');
const { validateEmail, validateNumber, validateRequiredFields } = require('../utils');
const { dbConfig } = require('../config/database');

// 获取所有用户
const getAllUsers = async (req, res) => {
  try {
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const dbUsers = await User.find({});
        res.status(200).json(dbUsers);
      } catch (dbError) {
        console.error('数据库查询失败:', dbError);
        // 降级到内存数据
        res.status(200).json(users);
      }
    } else {
      // 使用内存数据模式
      res.status(200).json(users);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '获取用户列表失败',
      message: error.message 
    });
  }
};

// 根据ID获取用户
const getUserById = async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '用户ID必须是数字' 
      });
    }
    
    const userId = parseInt(id);
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const user = await User.findById(userId);
        if (!user) {
          return res.status(404).json({ 
            error: '用户未找到',
            message: `ID为${userId}的用户不存在`
          });
        }
        res.status(200).json(user);
      } catch (dbError) {
        console.error('数据库查询失败:', dbError);
        // 降级到内存数据
        const user = users.find(u => u.id === userId);
        if (!user) {
          return res.status(404).json({ 
            error: '用户未找到',
            message: `ID为${userId}的用户不存在`
          });
        }
        res.status(200).json(user);
      }
    } else {
      // 使用内存数据模式
      const user = users.find(u => u.id === userId);
      if (!user) {
        return res.status(404).json({ 
          error: '用户未找到',
          message: `ID为${userId}的用户不存在`
        });
      }
      res.status(200).json(user);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '获取用户信息失败',
      message: error.message 
    });
  }
};

// 创建新用户
const createUser = async (req, res) => {
  try {
    const { name, email } = req.body;
    
    // 验证必填字段
    const validation = validateRequiredFields({ name, email }, ['name', 'email']);
    if (!validation.isValid) {
      return res.status(400).json({ 
        error: '字段验证失败', 
        message: validation.errors.join(', ') 
      });
    }
    
    // 验证邮箱格式
    if (!validateEmail(email)) {
      return res.status(400).json({ 
        error: '邮箱格式错误', 
        message: '请输入有效的邮箱地址' 
      });
    }
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const existingUser = await User.findOne({ email });
        if (existingUser) {
          return res.status(400).json({ 
            error: '用户已存在', 
            message: '该邮箱已被注册' 
          });
        }
        
        const newUser = new User({ name, email });
        const savedUser = await newUser.save();
        res.status(201).json(savedUser);
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const existingUser = users.find(u => u.email === email);
        if (existingUser) {
          return res.status(400).json({ 
            error: '用户已存在', 
            message: '该邮箱已被注册' 
          });
        }
        
        const newUser = new User(generateId(users), name, email);
        users.push(newUser);
        res.status(201).json(newUser);
      }
    } else {
      // 使用内存数据模式
      const existingUser = users.find(u => u.email === email);
      if (existingUser) {
        return res.status(400).json({ 
          error: '用户已存在', 
          message: '该邮箱已被注册' 
        });
      }
      
      const newUser = new User(generateId(users), name, email);
      users.push(newUser);
      res.status(201).json(newUser);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '创建用户失败',
      message: error.message 
    });
  }
};

// 更新用户
const updateUser = async (req, res) => {
  try {
    const { id } = req.params;
    const { name, email } = req.body;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '用户ID必须是数字' 
      });
    }
    
    const userId = parseInt(id);
    
    // 验证必填字段
    const validation = validateRequiredFields({ name, email }, ['name', 'email']);
    if (!validation.isValid) {
      return res.status(400).json({ 
        error: '字段验证失败', 
        message: validation.errors.join(', ') 
      });
    }
    
    // 验证邮箱格式
    if (!validateEmail(email)) {
      return res.status(400).json({ 
        error: '邮箱格式错误', 
        message: '请输入有效的邮箱地址' 
      });
    }
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const user = await User.findByIdAndUpdate(
          userId, 
          { name, email }, 
          { new: true, runValidators: true }
        );
        
        if (!user) {
          return res.status(404).json({ 
            error: '用户未找到',
            message: `ID为${userId}的用户不存在`
          });
        }
        
        res.status(200).json(user);
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const userIndex = users.findIndex(u => u.id === userId);
        if (userIndex === -1) {
          return res.status(404).json({ 
            error: '用户未找到',
            message: `ID为${userId}的用户不存在`
          });
        }
        
        users[userIndex].name = name;
        users[userIndex].email = email;
        res.status(200).json(users[userIndex]);
      }
    } else {
      // 使用内存数据模式
      const userIndex = users.findIndex(u => u.id === userId);
      if (userIndex === -1) {
        return res.status(404).json({ 
          error: '用户未找到',
          message: `ID为${userId}的用户不存在`
        });
      }
      
      users[userIndex].name = name;
      users[userIndex].email = email;
      res.status(200).json(users[userIndex]);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '更新用户失败',
      message: error.message 
    });
  }
};

// 删除用户
const deleteUser = async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '用户ID必须是数字' 
      });
    }
    
    const userId = parseInt(id);
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const user = await User.findByIdAndDelete(userId);
        if (!user) {
          return res.status(404).json({ 
            error: '用户未找到',
            message: `ID为${userId}的用户不存在`
          });
        }
        
        res.status(200).json({ message: '用户删除成功' });
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const userIndex = users.findIndex(u => u.id === userId);
        if (userIndex === -1) {
          return res.status(404).json({ 
            error: '用户未找到',
            message: `ID为${userId}的用户不存在`
          });
        }
        
        users.splice(userIndex, 1);
        res.status(200).json({ message: '用户删除成功' });
      }
    } else {
      // 使用内存数据模式
      const userIndex = users.findIndex(u => u.id === userId);
      if (userIndex === -1) {
        return res.status(404).json({ 
          error: '用户未找到',
          message: `ID为${userId}的用户不存在`
        });
      }
      
      users.splice(userIndex, 1);
      res.status(200).json({ message: '用户删除成功' });
    }
  } catch (error) {
    res.status(500).json({ 
      error: '删除用户失败',
      message: error.message 
    });
  }
};

module.exports = {
  getAllUsers,
  getUserById,
  createUser,
  updateUser,
  deleteUser
};